Expand description
SPECS Parallel ECS
This library provides an ECS variant designed for parallel execution and convenient usage. It is highly flexible when it comes to actual component data and the way it is stored and accessed.
Features:
- depending on chosen features either 0 virtual function calls or one per system
- parallel iteration over components
- parallel execution of systems
High-level overview
One could basically split this library up into two parts: The data part and the execution part.
The data
World is where component storages, resources and entities are stored.
See the docs of World for more.
Components can be easily implemented like this:
use specs::prelude::*;
struct MyComp;
impl Component for MyComp {
type Storage = VecStorage<Self>;
}Or alternatively, if you import the specs-derive crate, you can use a
custom #[derive] macro:
#[macro_use]
extern crate specs_derive;
use specs::prelude::*;
#[derive(Component)]
#[storage(VecStorage)]
struct MyComp;You can choose different storages according to your needs.
These storages can be joined together, for example joining a Velocity
and a Position storage means you’ll only get entities which have both of them.
Thanks to rayon, this is even possible in parallel! See ParJoin for more.
System execution
Here we have System and Dispatcher as our core types. Both types
are provided by a library called shred.
The Dispatcher can be seen as an optional part here;
it allows dispatching the systems in parallel, given a list
of systems and their dependencies on other systems.
If you don’t like it, you can also execute the systems yourself
by using RunNow.
Systems are traits with a run() method and an associated
SystemData, allowing type-safe aspects (knowledge about the
reads / writes of the systems).
Examples
This is a basic example of using Specs:
extern crate specs;
use specs::prelude::*;
// A component contains data which is
// associated with an entity.
struct Vel(f32);
impl Component for Vel {
type Storage = VecStorage<Self>;
}
struct Pos(f32);
impl Component for Pos {
type Storage = VecStorage<Self>;
}
struct SysA;
impl<'a> System<'a> for SysA {
// These are the resources required for execution.
// You can also define a struct and `#[derive(SystemData)]`,
// see the `full` example.
type SystemData = (WriteStorage<'a, Pos>, ReadStorage<'a, Vel>);
fn run(&mut self, (mut pos, vel): Self::SystemData) {
// The `.join()` combines multiple components,
// so we only access those entities which have
// both of them.
// This joins the component storages for Position
// and Velocity together; it's also possible to do this
// in parallel using rayon's `ParallelIterator`s.
// See `ParJoin` for more.
for (pos, vel) in (&mut pos, &vel).join() {
pos.0 += vel.0;
}
}
}
fn main() {
// The `World` is our
// container for components
// and other resources.
let mut world = World::new();
world.register::<Pos>();
world.register::<Vel>();
// An entity may or may not contain some component.
world.create_entity().with(Vel(2.0)).with(Pos(0.0)).build();
world.create_entity().with(Vel(4.0)).with(Pos(1.6)).build();
world.create_entity().with(Vel(1.5)).with(Pos(5.4)).build();
// This entity does not have `Vel`, so it won't be dispatched.
world.create_entity().with(Pos(2.0)).build();
// This builds a dispatcher.
// The third parameter of `add` specifies
// logical dependencies on other systems.
// Since we only have one, we don't depend on anything.
// See the `full` example for dependencies.
let mut dispatcher = DispatcherBuilder::new().with(SysA, "sys_a", &[]).build();
// This dispatches all the systems in parallel (but blocking).
dispatcher.dispatch(&mut world.res);
}You can also easily create new entities on the fly:
use specs::prelude::*;
struct EnemySpawner;
impl<'a> System<'a> for EnemySpawner {
type SystemData = Entities<'a>;
fn run(&mut self, entities: Entities<'a>) {
let enemy = entities.create();
}
}See the repository’s examples directory for more examples.
Re-exports
pub extern crate shred;pub use join::Join;pub use changeset::ChangeSet;pub use storage::Storage;pub use world::Builder;pub use world::EntityBuilder;pub use world::World;Modules
Structs
Dispatcher but works asynchronously.BitSet is a simple set designed to track which indices are placed
into it.Dispatcher.Entity type, as seen by the user.EventChannel.world.maintain().EventChannel.SystemData.Vec. Supposed to have maximum
performance for the components mostly present in entities.Traits
ParJoin trait is to provide a way
to access multiple storages in parallel at the same time with
the merged bit set.SystemData, the DynamicSystemData type is only needed for very special
setups.UnprotectedStorages that track modifications, insertions, and
removals of components.Type Definitions
Entities resource.
Note that this is just Read<Entities>, so
you can easily use it in your system:Read or Option<Read> is therefore recommended.Write or Option<Write> is therefore recommended.